%% @author 
%% @doc @todo Add description to maxteilsummeR.


-module(maxteilsummeRekMitIndizesMitZugr).

%% ====================================================================
%% API functions
%% ====================================================================
-export([linkesRandMax/4, rechtesRandMax/4, maxTeilsummeRekursiv/1, teilen/1]).



%% ====================================================================
%% Internal functions
%% ====================================================================

deleteLast(L) -> lists:sublist(L,length(L)-1).

linkesRandMax(L, Von, Bis, Zugr) -> linkesRandMax(L, 0, 0, Von, Bis + 1, {0,0}, Zugr).
linkesRandMax([], BischerMax, _, Von, Bis, VonBis, Zugr) -> {BischerMax, VonBis, Zugr};
linkesRandMax(L, BischerMax, BischerSum, Von, Bis, VonBis, Zugr) -> case lists:sum(L) > BischerMax of
							  true -> linkesRandMax(deleteLast(L), lists:sum(L), BischerSum + lists:sum(L), Von, Bis - 1, {Von, Bis - 1}, Zugr + 4);
				     		  false -> linkesRandMax(deleteLast(L), BischerMax, BischerSum + lists:sum(L), Von, Bis - 1, VonBis, Zugr + 3) end.
	
rechtesRandMax([H|T], Von, Bis, Zugr) -> rechtesRandMax([H|T], 0, 0, Von, Bis, {0,0}, Zugr).
rechtesRandMax([], BischerMax1, _, Von, Bis, VonBis, Zugr) -> {BischerMax1, VonBis, Zugr};
rechtesRandMax([H|T], BischerMax1, BischerSum1, Von, Bis, VonBis, Zugr) -> case lists:sum([H|T]) > BischerMax1 of
							  true -> rechtesRandMax(T, lists:sum([H|T]), BischerSum1 + lists:sum([H|T]), Von + 1, Bis, {Von, Bis}, Zugr + 4);
				     		  false -> rechtesRandMax(T, BischerMax1, BischerSum1 + lists:sum([H|T]), Von + 1, Bis, VonBis, Zugr + 3) end.


maxTeilsummeRekursiv([]) -> {0, 0, 0, 0};
maxTeilsummeRekursiv(L) -> maxTeilsummeRekursiv(L, 1, length(L), 1).
maxTeilsummeRekursiv(L, Von, Bis, Zugr) -> if length(L) =:= 1 -> {max(hd(L),0), Von, Bis, Zugr + 2};
						true -> maxTeilsummeRekursiv(hd(teilen(L)), lists:flatten(tl(teilen(L))), Von, Bis, Zugr + 2) end.
maxTeilsummeRekursiv(H, T, Von, Bis, Zugr) ->
		{Sum2, Von2, Bis2, Zugr2} = maxTeilsummeRekursiv(T, Von + length(H), Bis, Zugr + 2),
		{Sum1,Von1,Bis1, Zugr1} = maxTeilsummeRekursiv(H, Von, Bis - length(T), Zugr + 2),
		{BischerMaxR, {VonR,BisR}, ZugrR} = rechtesRandMax(H, Von, Bis - length(T), Zugr + 2),
		{BischerMaxL, {VonL,BisL}, ZugrL} = linkesRandMax(T, Von + length(H), Bis, Zugr + 2),
		SumM = BischerMaxR + BischerMaxL,
		ZugrM = ZugrR + ZugrL,
	    if 
		   (Sum1 >= Sum2) and (Sum1 >= SumM) -> SumErg = Sum1, VonErg = Von1, BisErg = Bis1, ZugrErg = Zugr1;
		   (Sum2 >= Sum1) and (Sum2 >= SumM) -> SumErg = Sum2, VonErg = Von2, BisErg = Bis2, ZugrErg = Zugr2;
		   (SumM >= Sum2) and (SumM >= Sum1) -> SumErg = SumM, VonErg = VonR, BisErg = BisL, ZugrErg = ZugrM
		end,
		{SumErg,VonErg,BisErg, ZugrErg}.
							
teilen(L) -> tuple_to_list(lists:split(round(length(L)/2), L)).				



